/**
 * 枚举值仓库
 * 用于存储和管理操作日志页面的下拉框选项数据
 */

import { create } from 'zustand';
import { persist } from 'zustand/middleware';

/**
 * 枚举项接口
 */
export interface EnumItem {
  value: string;
  label: string;
}

/**
 * 枚举值仓库状态接口
 */
interface EnumStoreState {
  // 用户角色枚举值
  userRoles: EnumItem[];
  // 操作模块枚举值
  modules: EnumItem[];
  // 操作类型枚举值
  operationTypes: EnumItem[];
  // 请求方法枚举值
  requestMethods: EnumItem[];
  // 设置用户角色枚举值
  setUserRoles: (roles: EnumItem[]) => void;
  // 设置操作模块枚举值
  setModules: (modules: EnumItem[]) => void;
  // 设置操作类型枚举值
  setOperationTypes: (types: EnumItem[]) => void;
  // 设置请求方法枚举值
  setRequestMethods: (methods: EnumItem[]) => void;
  // 从操作日志数据中提取并更新枚举值
  updateFromLogs: (logs: OPERATION_LOG.OperationLogModel[]) => void;
  // 转换为ProTable的valueEnum格式
  toValueEnum: (items: EnumItem[]) => Record<string, { text: string }>;
}

/**
 * 创建枚举值仓库
 */
export const useEnumStore = create<EnumStoreState>(
  persist(
    (set, get) => ({
      userRoles: [],
      modules: [],
      operationTypes: [],
      requestMethods: [],
      
      setUserRoles: (roles) => set({ userRoles: roles }),
      setModules: (modules) => set({ modules }),
      setOperationTypes: (types) => set({ operationTypes: types }),
      setRequestMethods: (methods) => set({ requestMethods: methods }),
      
      /**
       * 从操作日志数据中提取并更新枚举值
       * @param logs 操作日志数据列表
       */
      updateFromLogs: (logs) => {
        const { userRoles, modules, operationTypes, requestMethods } = get();
        
        // 提取并合并用户角色
        const newUserRoles = [...userRoles];
        logs.forEach(log => {
          if (log.userRole && !newUserRoles.some(role => role.value === log.userRole)) {
            // 使用更友好的标签名称（如果可能）
            let label = log.userRole;
            // 可以在这里添加一些常见角色的映射
            if (log.userRole === 'admin') label = '管理员';
            if (log.userRole === 'user') label = '普通用户';
            if (log.userRole === 'guest') label = '访客';
            if (log.userRole === 'operator') label = '操作员';
            
            newUserRoles.push({ value: log.userRole, label });
          }
        });
        
        // 提取并合并操作模块
        const newModules = [...modules];
        logs.forEach(log => {
          if (log.module && !newModules.some(module => module.value === log.module)) {
            // 使用更友好的标签名称（如果可能）
            let label = log.module;
            // 可以在这里添加一些常见模块的映射
            if (log.module === 'user') label = '用户管理';
            if (log.module === 'product') label = '产品管理';
            if (log.module === 'order') label = '订单管理';
            if (log.module === 'system') label = '系统设置';
            if (log.module === 'log') label = '日志管理';
            if (log.module === 'dashboard') label = '仪表盘';
            
            newModules.push({ value: log.module, label });
          }
        });
        
        // 提取并合并操作类型
        const newOperationTypes = [...operationTypes];
        logs.forEach(log => {
          if (log.operation && !newOperationTypes.some(type => type.value === log.operation)) {
            // 使用更友好的标签名称（如果可能）
            let label = log.operation;
            // 可以在这里添加一些常见操作类型的映射
            if (log.operation === 'create') label = '新增';
            if (log.operation === 'update') label = '修改';
            if (log.operation === 'delete') label = '删除';
            if (log.operation === 'query') label = '查询';
            if (log.operation === 'import') label = '导入';
            if (log.operation === 'export') label = '导出';
            if (log.operation === 'login') label = '登录';
            if (log.operation === 'logout') label = '登出';
            
            newOperationTypes.push({ value: log.operation, label });
          }
        });
        
        // 提取并合并请求方法
        const newRequestMethods = [...requestMethods];
        logs.forEach(log => {
          if (log.method && !newRequestMethods.some(method => method.value === log.method)) {
            // 请求方法通常使用原始值作为标签
            newRequestMethods.push({ value: log.method, label: log.method });
          }
        });
        
        // 更新状态
        set({
          userRoles: newUserRoles,
          modules: newModules,
          operationTypes: newOperationTypes,
          requestMethods: newRequestMethods,
        });
      },
      
      /**
       * 转换为ProTable的valueEnum格式
       * @param items 枚举项列表
       * @returns valueEnum格式的对象
       */
      toValueEnum: (items) => {
        const valueEnum: Record<string, { text: string }> = {};
        items.forEach(item => {
          valueEnum[item.value] = { text: item.label };
        });
        return valueEnum;
      },
    }),
    {
      name: 'operation-log-enums', // 持久化存储的键名
    }
  )
);